﻿using System;
using System.Collections.Generic;
using TPDiseño.Clases_de_Entidad;
using DAO.DataSetConsultoraTableAdapters;

namespace DAO
{
    public class DAOCompetencia : DAO
    {
        //Atributos de manejo de instancia (singleton)
        static DAOCompetencia instance = null; 
        // Atributos para acceso a los DataSet Tipados
        private DataSetConsultora.CompetenciaDataTable competenciaTabla = new DataSetConsultora.CompetenciaDataTable();
        private CompetenciaTableAdapter competenciaTableAdapter = new CompetenciaTableAdapter();
        // Dependencias de otros DAOs
        private DAOFactor miDAOFactor = DAOFactor.Instance;

        public static DAOCompetencia Instance
        {
            get
            {
                if (instance == null)
                {
                    lock (padlock)
                    {
                        if (instance == null)
                        {
                            instance = new DAOCompetencia();
                        }
                    }
                }
                return instance;
            }
        }

        public Competencia guardar(Competencia unaCompetencia)
        {
            competenciaTableAdapter.insertar(unaCompetencia._nombre);
            
            return recolectarUno();
        }

        public List<Competencia> cargar()
        {

            // Cargo todos los puesto de la db
            competenciaTabla = competenciaTableAdapter.GetData();

            // Finalmente devuelvo la lista de puestosCargados, recolectadas por la funcion            
            return recolectar();
        }

        public Competencia cargar(Int32 unId)
        {

            // obtengo la empresa por id en empresaTabla
            competenciaTabla = competenciaTableAdapter.consultarPor(unId);

            // Finalmente retorno un nuevo objeto Empresa mapeado de la tabla
            return recolectarUno();


        }

        public Competencia recolectarUno()
        {

            // Finalmente retorno un nuevo objeto Empresa mapeado de la tabla
            return new Competencia(competenciaTabla[0].id,
                                   competenciaTabla[0].nombre,
                                   "",
                                   miDAOFactor.cargar(competenciaTabla[0].id)
                                   );


        }

        private List<Competencia> recolectar()
        {

            // Creo la lista para recolectar y devolver los puestos cargados de la db
            List<Competencia> competenciasCargados = new List<Competencia>();

            // Recorro los puestos de la tabla
            foreach (DataSetConsultora.CompetenciaRow unaCompetenciaFila in competenciaTabla)
            {

                // Creo un puesto y lo agrego a la lista de puestos cargados
                competenciasCargados.Add(new Competencia(unaCompetenciaFila.id,
                                                         unaCompetenciaFila.nombre,
                                                          "",
                                                          miDAOFactor.cargar(unaCompetenciaFila.id)
                                                        )
                                    );

            }

            return competenciasCargados;
        }

    }
}




